home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 7 / Night Owl Shareware (NOPV7)(Night Owl Publisher Inc.)(1992).bin / 038a / bash1_12.arj / BASH1-12.TAR / bash-1.12 / builtins / fc.def < prev    next >
Text File  |  1991-12-29  |  16KB  |  690 lines
  1. This file is fc.def, from which is created fc.c.
  2. It implements the builtin "fc" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES fc.c
  23.  
  24. $BUILTIN fc
  25. $FUNCTION fc_builtin
  26. $SHORT_DOC fc [-e ename] [-nlr] [first] [last] or fc -s [pat=rep] [cmd]
  27.  
  28. FIRST and LAST can be numbers specifying the range, or FIRST can be a
  29. string, which means the most recent command beginning with that
  30. string.
  31.  
  32.    -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,
  33.       then the editor which corresponds to the current readline editing
  34.       mode, then vi.
  35.  
  36.    -l means list lines instead of editing.
  37.    -n means no line numbers listed.
  38.    -r means reverse the order of the lines (making it newest listed first).
  39.  
  40. With the `fc -s [pat=rep ...] [command]' format, the command is
  41. re-executed after the substitution OLD=NEW is performed.
  42.  
  43. A useful alias to use with this is r='fc -s', so that typing `r cc'
  44. runs the last command beginning with `cc' and typing `r' re-executes
  45. the last command.
  46. $END
  47.  
  48. #include <stdio.h>
  49. #include <sys/param.h>
  50. #include <sys/types.h>
  51. #include <sys/stat.h>
  52. #include <sys/file.h>
  53. #include <errno.h>
  54. #include "../shell.h"
  55. #include "../builtins.h"
  56. #include "../flags.h"
  57. #include "../maxpath.h"
  58. #include <readline/history.h>
  59.  
  60. #if defined (NULL)
  61. #undef NULL
  62. #endif
  63. #define NULL 0
  64.  
  65. extern int errno;
  66.  
  67. /* **************************************************************** */
  68. /*                                    */
  69. /*    The K*rn shell style fc command (Fix Command)            */
  70. /*                                    */
  71. /* **************************************************************** */
  72.  
  73. /* fc builtin command (fix command) for Bash for those who
  74.    like K*rn-style history better than csh-style.
  75.  
  76.      fc [-e ename] [-nlr] [first] [last]
  77.  
  78.    FIRST and LAST can be numbers specifying the range, or FIRST can be
  79.    a string, which means the most recent command beginning with that
  80.    string.
  81.  
  82.    -e ENAME selects which editor to use.  Default is FCEDIT, then EDITOR,
  83.       then the editor which corresponds to the current readline editing
  84.       mode, then vi.
  85.  
  86.    -l means list lines instead of editing.
  87.    -n means no line numbers listed.
  88.    -r means reverse the order of the lines (making it newest listed first).
  89.  
  90.      fc -e - [pat=rep ...] [command]
  91.      fc -s [pat=rep ...] [command]
  92.  
  93.    Equivalent to !command:sg/pat/rep execpt there can be multiple PAT=REP's.
  94. */
  95.  
  96. static char *fc_dosubs (), *fc_replace (), *fc_gethist (), *fc_readline ();
  97. static int fc_gethnum ();
  98. static void fc_replhist (), fc_addhist ();
  99.  
  100. /* Data structure describing a list of global replacements to perform. */
  101. typedef struct repl {
  102.   struct repl *next;
  103.   char *pat;
  104.   char *rep;
  105. } REPL;
  106.  
  107. #define USAGE    "usage: fc [-e ename] [-nlr] [first] [last] or fc -s [pat=rep] [command]"
  108.  
  109. /* True if A is the first substring in B. */
  110. #define prefix(a, b) (strncmp ((a), (b), strlen ((a))) == 0)
  111.  
  112. /* Accessors for HIST_ENTRY lists that are called HLIST. */
  113. #define histline(i) (hlist[(i)]->line)
  114. #define histdata(i) (hlist[(i)]->data)
  115.  
  116. #define FREE_RLIST() \
  117.     do { \
  118.         for (rl = rlist; rl; ) { \
  119.             REPL *r;    \
  120. \
  121.             r = rl->next; \
  122.             if (rl->pat) \
  123.                 free (rl->pat); \
  124.             if (rl->rep) \
  125.                 free (rl->rep); \
  126.             free (rl); \
  127.             rl = r; \
  128.         } \
  129.     } while (0)
  130.  
  131. /* String to execute on a file that we want to edit. */
  132. #define FC_EDIT_COMMAND "${FCEDIT:-${EDITOR:-vi}}"
  133.  
  134. int
  135. fc_builtin (list)
  136.      WORD_LIST *list;
  137. {
  138.   register int i;
  139.   register char *sep;
  140.   int numbering, reverse, listing, execute;
  141.   int histbeg, histend, last_hist, retval, first;
  142.   FILE *stream;
  143.   REPL *rlist = (REPL *) NULL, *rl;
  144.   char *ename = NULL, *command, *newcom, *line;
  145.   HIST_ENTRY **hlist;
  146.   char fn[MAXPATHLEN];
  147.  
  148.   numbering = 1;
  149.   reverse = listing = execute = 0;
  150.  
  151.   /* Parse out the options and set which of the two forms we're in. */
  152.   while (list && *list->word->word == '-')
  153.     {
  154.       register char *s = &((list->word->word)[1]);
  155.       register int c;
  156.  
  157.       if (!isletter (*s))    /* for stuff like fc -e - -2 */
  158.     break;
  159.  
  160.       while (c = *s++)
  161.     {
  162.       switch (c)
  163.         {
  164.         case 'n':
  165.           numbering = 0;
  166.           break;
  167.  
  168.         case 'l':
  169.           listing = 1;
  170.           break;
  171.  
  172.         case 'r':
  173.           reverse = 1;
  174.           break;
  175.  
  176.         case 's':
  177.           execute = 1;
  178.           break;
  179.  
  180.         case 'e':
  181.           list = list->next;
  182.  
  183.           if (list == NULL)
  184.         {
  185.           builtin_error (USAGE);
  186.           return (EXECUTION_FAILURE);
  187.         }
  188.  
  189.           ename = list->word->word;
  190.           break;
  191.  
  192.         default:
  193.           builtin_error (USAGE);
  194.           return (EXECUTION_FAILURE);
  195.         }
  196.     }
  197.       list = list->next;
  198.     }
  199.  
  200.   if (ename && (*ename == '-') && (ename[1] == '\0'))
  201.     execute = 1;
  202.  
  203.   /* The "execute" form of the command (re-run, with possible string
  204.      substitutions). */
  205.   if (execute)
  206.     {
  207.       while (list && ((sep = (char *)index (list->word->word, '=')) != NULL))
  208.     {
  209.       *sep++ = '\0';
  210.       rl = (REPL *)xmalloc (sizeof (REPL));
  211.       rl->next = (REPL *)NULL;
  212.       rl->pat = savestring (list->word->word);
  213.       rl->rep = savestring (sep);
  214.  
  215.       if (rlist == NULL)
  216.         rlist = rl;
  217.       else
  218.         {
  219.           rl->next = rlist;
  220.           rlist = rl;
  221.         }
  222.       list = list->next;
  223.     }
  224.  
  225.       /* If we have a list of substitutions to do, then reverse it
  226.      to get the replacements in the proper order. */
  227.  
  228.       if (rlist && rlist->next)
  229.     rlist = (REPL *) reverse_list ((GENERIC_LIST *) rlist);
  230.  
  231.       hlist = history_list ();
  232.  
  233.       /* If we still have something in list, it is a command spec.
  234.      Otherwise, we use the most recent command in time. */
  235.       if (list)
  236.     command = fc_gethist (list->word->word, hlist);
  237.       else
  238.     command = fc_gethist ((char *) NULL, hlist);
  239.  
  240.       if (command == NULL)
  241.     {
  242.       builtin_error ("no command found");
  243.       if (rlist)
  244.         FREE_RLIST ();
  245.  
  246.       return (EXECUTION_FAILURE);
  247.     }
  248.  
  249.       if (rlist)
  250.     {
  251.       newcom = fc_dosubs (command, rlist);
  252.       free (command);
  253.       FREE_RLIST ();
  254.       command = newcom;
  255.     }
  256.  
  257.       printf ("%s\n", command);
  258.       fc_replhist (command);    /* replace `fc -e -' with command */
  259.       return (parse_and_execute (command, "fc"));
  260.     }
  261.  
  262.   /* This is the second form of the command (the list-or-edit-and-rerun
  263.      form). */
  264.   hlist = history_list ();
  265.   for (i = 0; hlist[i]; i++);
  266.  
  267.   /* With the Bash implementation of history, the current command line
  268.      ("fc blah..." and so on) is already part of the history list by
  269.      the time we get to this point.  This just skips over that command
  270.      and makes the last command that this deals with be the last command
  271.      the user entered before the fc. */
  272.  
  273.   last_hist = i - 2;
  274.  
  275.   if (list)
  276.     {
  277.       histbeg = fc_gethnum (list->word->word, hlist);
  278.       list = list->next;
  279.  
  280.       if (list)
  281.     histend = fc_gethnum (list->word->word, hlist);
  282.       else
  283.     {
  284.       if (listing)
  285.         histend = last_hist;
  286.       else
  287.         histend = histbeg;
  288.     }
  289.     }
  290.   else
  291.     {
  292.       /* The default for listing is the last 16 history items. */
  293.       if (listing)
  294.     {
  295.       histend = last_hist;
  296.       histbeg = histend - 16;
  297.     }
  298.       else
  299.     {
  300.       /* For editing, it is the last history command. */
  301.       histbeg = histend = last_hist;
  302.       }
  303.     }
  304.  
  305.   /* We print error messages for line specifications out of range. */
  306.   if ((histbeg < 0) || (histend < 0) ||
  307.       (histbeg > last_hist) || (histend > last_hist))
  308.     {
  309.       builtin_error ("history specification out of range");
  310.       return (EXECUTION_FAILURE);
  311.     }
  312.  
  313.   if (histend < histbeg)
  314.     {
  315.       int t = histend;
  316.  
  317.       histend = histbeg;
  318.       histbeg = t;
  319.       reverse = 1;
  320.     }
  321.  
  322.   if (listing)
  323.     stream = stdout;
  324.   else
  325.     {
  326.       numbering = 0;
  327.       sprintf (fn, "/tmp/bash%d", (int)time ((long *) 0) + (int)getpid ());
  328.  
  329.       stream = fopen (fn, "w");
  330.  
  331.       if (!stream)
  332.     {
  333.       builtin_error ("cannot open temp file %s", fn);
  334.       return (EXECUTION_FAILURE);
  335.     }
  336.     }
  337.  
  338.   if (!reverse)
  339.     {
  340.       for (i = histbeg; i <= histend; i++)
  341.     {
  342.       QUIT;
  343.       if (numbering)
  344.         fprintf (stream, "%d\t%c", i + history_base,
  345.              histdata (i) ? '*' : ' ');
  346.  
  347.       fprintf (stream, "%s\n", histline (i));
  348.     }
  349.     }
  350.   else
  351.     {
  352.       for (i = histend; i >= histbeg; i--)
  353.     {
  354.       QUIT;
  355.       if (numbering)
  356.         fprintf (stream, "%d\t%c", i + history_base,
  357.              histdata (i) ? '*' : ' ');
  358.       fprintf (stream, "%s\n", histline (i));
  359.     }
  360.     }
  361.  
  362.   if (listing)
  363.     return (EXECUTION_SUCCESS);
  364.  
  365.   fclose (stream);
  366.  
  367.   /* Now edit the file of commands. */
  368.   if (ename)
  369.     {
  370.       command = (char *)xmalloc (strlen (ename) + strlen (fn) + 2);
  371.       sprintf (command, "%s %s", ename, fn);
  372.     }
  373.   else
  374.     {
  375.       command = (char *)xmalloc (3 + strlen (FC_EDIT_COMMAND) + strlen (fn));
  376.       sprintf (command, "%s %s", FC_EDIT_COMMAND, fn);
  377.     }
  378.   parse_and_execute (command, "fc");
  379.  
  380.   /* Now reopen the file and execute the edited commands. */
  381.  
  382.   stream = fopen (fn, "r");
  383.  
  384.   if (stream == NULL)
  385.     {
  386.       builtin_error ("cannot reopen temp file %s", fn);
  387.       unlink (fn);
  388.       return (EXECUTION_FAILURE);
  389.     }
  390.  
  391.   retval = EXECUTION_SUCCESS;
  392.   first = 1;
  393.  
  394.   /* First, write the commands to the history file.  This will not happen
  395.      when we call parse_and_execute, since parse_and_execute disables
  396.      the command line history while it executes. */
  397.      
  398.   while ((line = fc_readline (stream)) != NULL)
  399.     {
  400.       if (line[0] == '\n')
  401.     {
  402.       free (line);
  403.       continue;        /* Skip blank lines. */
  404.     }
  405.  
  406.       if (first)
  407.     {
  408.       first = 0;
  409.       fc_replhist (line);
  410.     }
  411.       else
  412.     fc_addhist (line);
  413.     }
  414.   fclose (stream);
  415.  
  416.   {
  417.     extern int echo_input_at_read;
  418.     extern int unlink ();
  419.  
  420.     /* Turn on the `v' flag while maybe_execute_file runs so the commands
  421.        will be echoed as they are read by the parser. */
  422.     begin_unwind_frame ("fc builtin");
  423.     add_unwind_protect (unlink, fn);
  424.     unwind_protect_int (echo_input_at_read);
  425.     echo_input_at_read = 1;
  426.     
  427.     retval = maybe_execute_file (fn);
  428.  
  429.     run_unwind_frame ("fc builtin");
  430.   }
  431.  
  432.   return (retval);
  433. }
  434.  
  435. /* Return an absolute index into HLIST which corresponds to COMMAND.  If
  436.    COMMAND is a number, then it was specified in relative terms.  If it
  437.    is a string, then it is the start of a command line present in HLIST. */
  438. static int
  439. fc_gethnum (command, hlist)
  440.      char *command;
  441.      HIST_ENTRY **hlist;
  442. {
  443.   int sign = 1, n;
  444.   register int i, j;
  445.   register char *s;
  446.  
  447.   /* Count history elements. */
  448.   for (i = 0; hlist[i]; i++);
  449.  
  450.   /* With the Bash implementation of history, the current command line
  451.      ("fc blah..." and so on) is already part of the history list by
  452.      the time we get to this point.  This just skips over that command
  453.      and makes the last command that this deals with be the last command
  454.      the user entered before the fc. */
  455.   i -= 2;
  456.  
  457.   /* No specification defaults to most recent command. */
  458.   if (command == NULL)
  459.     return (i);
  460.  
  461.   /* Otherwise, there is a specification.  It can be a number relative to
  462.      the current position, or an absolute history number. */
  463.   s = command;
  464.  
  465.   /* Handle possible leading minus sign. */
  466.   if (s && (*s == '-'))
  467.     {
  468.       sign = -1;
  469.       s++;
  470.     }
  471.  
  472.   if (s && digit(*s))
  473.     {
  474.       n = atoi (s);
  475.       n *= sign;
  476.  
  477.       /* Anything specified greater than the last history element that we
  478.      deal with is an error. */
  479.       if (n > i + history_base)
  480.     return (-1);
  481.  
  482.       /* If the value is negative or zero, then it is an offset from
  483.      the current history item. */
  484.       if (n <= 0)
  485.     return (i + n);
  486.  
  487.       return (n - history_base);
  488.     }
  489.  
  490.   for (j = i; j >= 0; j--)
  491.     {
  492.       if (prefix (command, histline (j)))
  493.     return (j);
  494.     }
  495.   return (-1);
  496. }
  497.  
  498. /* Locate the most recent history line which begins with
  499.    COMMAND in HLIST, and return a malloc()'ed copy of it. */
  500. static char *
  501. fc_gethist (command, hlist)
  502.      char *command;
  503.      HIST_ENTRY **hlist;
  504. {
  505.   int i;
  506.  
  507.   if (!hlist)
  508.     return ((char *)NULL);
  509.  
  510.   i = fc_gethnum (command, hlist);
  511.  
  512.   if (i >= 0)
  513.     return (savestring (histline (i)));
  514.   else
  515.     return ((char *)NULL);
  516. }
  517.  
  518. /* Read the edited history lines from STREAM and return them
  519.    one at a time.  This can read unlimited length lines.  The
  520.    caller should free the storage. */
  521. static char *
  522. fc_readline (stream)
  523.      FILE *stream;
  524. {
  525.   register int c;
  526.   int line_len = 0, lindex = 0;
  527.   char *line = (char *)NULL;
  528.  
  529.   while ((c = getc (stream)) != EOF)
  530.     {
  531.       if ((lindex + 2) >= line_len)
  532.     line = (char *) xrealloc (line, (line_len += 128));
  533.  
  534.       if (c == '\n')
  535.     {
  536.       line[lindex++] = '\n';
  537.       line[lindex++] = '\0';
  538.       return (line);
  539.     }
  540.       else
  541.     line[lindex++] = c;
  542.     }
  543.  
  544.   if (!lindex)
  545.     {
  546.       if (line)
  547.     free (line);
  548.  
  549.       return ((char *)NULL);
  550.     }
  551.  
  552.   if (lindex + 2 >= line_len)
  553.     line = (char *)xrealloc (line, lindex + 3);
  554.  
  555.   line[lindex++] = '\n';        /* Finish with newline if none in file */
  556.   line[lindex++] = '\0';
  557.   return (line);
  558. }
  559.  
  560. /* Perform the SUBS on COMMAND.
  561.    SUBS is a list of substitutions, and COMMAND is a simple string.
  562.    Return a pointer to a malloc'ed string which contains the substituted
  563.    command. */
  564. static char *
  565. fc_dosubs (command, subs)
  566.      char *command;
  567.      REPL *subs;
  568. {
  569.   register char *new = savestring (command);
  570.   register REPL *r;
  571.  
  572.   for (r = subs; r; r = r->next)
  573.     {
  574.       register char *t;
  575.  
  576.       t = fc_replace (r->pat, r->rep, new);
  577.       free (new);
  578.       new = t;
  579.     }
  580.   return (new);
  581. }
  582.  
  583. /* Replace the occurrences of PAT with REP in COMMAND.
  584.    This returns a new string; the caller should free it. */
  585. static char *
  586. fc_replace (pat, rep, command)
  587.      char *pat, *rep, *command;
  588. {
  589.   register int i;
  590.   int patlen, replen, templen;
  591.   char *new, *temp;
  592.  
  593.   patlen = strlen (pat);
  594.   replen = strlen (rep);
  595.  
  596.   temp = savestring (command);
  597.   templen = strlen (temp);
  598.   i = 0;
  599.  
  600.   for (; (i + patlen) <= templen; i++)
  601.     {
  602.       if (strncmp (temp + i, pat, patlen) == 0)
  603.     {
  604.       new = (char *) xmalloc (1 + (replen - patlen) + templen);
  605.  
  606.       strncpy (new, temp, i);
  607.       strncpy (new + i, rep, replen);
  608.       strncpy (new + i + replen,
  609.            temp + i + patlen, templen - (i + patlen));
  610.       new[templen + (replen - patlen)] = '\0'; /* just in case */
  611.  
  612.       free (temp);
  613.       temp = new;
  614.       i += replen;
  615.       templen = strlen (temp);
  616.     }
  617.     }
  618.   return (temp);
  619. }
  620.  
  621. /* Use `command' to replace the last entry in the history list, which,
  622.    by this time, is `fc blah...'.  The intent is that the new command
  623.    become the history entry, and that `fc' should never appear in the
  624.    history list.  This way you can do `r' to your heart's content.
  625.  
  626.    Should this do anything with the history_control variable? */
  627. static void
  628. fc_replhist (command)
  629.      char *command;
  630. {
  631.   register int i;
  632.   HIST_ENTRY **hlist, *histent, *discard, *history_get ();
  633.   char *data;
  634.   int n;
  635.  
  636.   if (command == NULL || *command == NULL)
  637.     return;
  638.  
  639.   hlist = history_list ();
  640.  
  641.   if (hlist == NULL)
  642.     return;
  643.  
  644.   for (i = 0; hlist[i]; i++);
  645.   i--;
  646.  
  647.   /* History_get () takes a parameter that should be
  648.      offset by history_base. */
  649.  
  650.   histent = history_get (history_base + i);    /* Don't free this */
  651.   if (histent == NULL)
  652.     return;
  653.  
  654.   if (histent->data)
  655.     data = savestring (histent->data);
  656.   else
  657.     data = (char *) NULL;
  658.  
  659.   n = strlen (command);
  660.  
  661.   if (command[n - 1] == '\n')
  662.     command[n - 1] = '\0';
  663.  
  664.   if (command && *command)
  665.     {
  666.       discard = replace_history_entry (i, command, data);
  667.       if (discard)
  668.     {
  669.       if (discard->line)
  670.         free (discard->line);
  671.  
  672.       free ((char *) discard);
  673.     }
  674.     }
  675. }
  676.  
  677. /* Add LINE to the history, after removing a single trailing newline. */
  678. static void
  679. fc_addhist (line)
  680.      char *line;
  681. {
  682.   register int n = strlen (line);
  683.  
  684.   if (line[n - 1] == '\n')
  685.     line[n - 1] = '\0';
  686.  
  687.   if (line && *line)
  688.     add_history (line);
  689. }
  690.